{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    !pip install gym[all]\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 01. DQN\n",
    "\n",
    "[V. Mnih et al., \"Human-level control through deep reinforcement learning.\" Nature, 518\n",
    "(7540):529–533, 2015.](https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf)\n",
    "\n",
    "Reinforcement learning is known to be unstable or even to diverge when a nonlinear function approximator such as a neural network is used to represent the action-value (also known as $Q$) function. This instability has several causes: the correlations present in the sequence of observations, the fact that small updates to $Q$ may significantly change the policy and therefore change the data distribution, and the correlations between the action-values ($Q$) and the target values $r + \\gamma \\max_{a'} Q(s', a')$.\n",
    "\n",
    "The authors suggest two key ideas to address these instabilities with a novel variant of Q-learning: Replay buffer and Fixed Q-target.\n",
    "\n",
    "#### Uniformly random sampling from Experience Replay Memory\n",
    "\n",
    "Reinforcement learning agent stores the experiences consecutively in the buffer, so adjacent ($s, a, r, s'$) transitions stored are highly likely to have correlation. To remove this, the agent samples experiences uniformly at random from the pool of stored samples $\\big( (s, a, r, s') \\sim U(D) \\big)$. See sample_batch method of ReplayBuffer class for more details.\n",
    "\n",
    "#### Fixed Q-target\n",
    "\n",
    "DQN uses an iterative update that adjusts the action-values ($Q$) towards target values that are only periodically updated, thereby reducing correlations with the target; if not, it is easily divergy because the target continuously moves. The Q-learning update at iteration $i$ uses the following loss function:\n",
    "\n",
    "$$\n",
    "L_i(\\theta_i) = \\mathbb{E}_{(s,a,r,s') \\sim U(D)} \\big[ \\big( r + \\gamma \\max_{a'} Q(s',a';\\theta_i^-) - Q(s, a; \\theta_i) \\big)^2 \\big]\n",
    "$$\n",
    "\n",
    "in which $\\gamma$ is the discount factor determining the agent’s horizon, $\\theta_i$ are the parameters of the Q-network at iteration $i$ and $\\theta_i^-$ are the network parameters used to compute the target at iteration $i$. The target network parameters $\\theta_i^-$ are only updated with the Q-network parameters ($\\theta_i$) every C steps and are held fixed between individual updates. ($C = 200$ in CartPole-v0)\n",
    "\n",
    "#### For more stability: Gradient clipping\n",
    "\n",
    "The authors also found it helpful to clip the error term from the update $r + \\gamma \\max_{a'} Q(s', a'; \\theta_i^-) - Q(s,a,;\\theta_i)$ to be between -1 and 1. Because the absolute value loss function $|x|$ has a derivative of -1 for all negative values of x and a derivative of 1 for all positive values of x, clipping the squared error to be between -1 and 1 corresponds to using an absolute value loss function for errors outside of the (-1,1) interval. This form of error clipping further improved the stability of the algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Typically, people implement replay buffers with one of the following three data structures:\n",
    "\n",
    "  - collections.deque\n",
    "  - list\n",
    "  - numpy.ndarray\n",
    "  \n",
    "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of  *Get item* is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
    "\n",
    "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference). Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
    "\n",
    "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
    "\n",
    "\n",
    "Reference: [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = self.env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self) -> List[np.ndarray]:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "\n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(\n",
    "            next_state\n",
    "        ).max(dim=1, keepdim=True)[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py) and [configurations](https://github.com/openai/gym/blob/master/gym/envs/__init__.py#L53) of CartPole-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"CartPole-v0\"\n",
    "env = gym.make(env_id)\n",
    "if IN_COLAB:\n",
    "    env = gym.wrappers.Monitor(env, \"videos\", force=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 20000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 100\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  157.0\n"
     ]
    }
   ],
   "source": [
    "frames = agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Define the Animation class */\n",
       "  function Animation(frames, img_id, slider_id, interval, loop_select_id){\n",
       "    this.img_id = img_id;\n",
       "    this.slider_id = slider_id;\n",
       "    this.loop_select_id = loop_select_id;\n",
       "    this.interval = interval;\n",
       "    this.current_frame = 0;\n",
       "    this.direction = 0;\n",
       "    this.timer = null;\n",
       "    this.frames = new Array(frames.length);\n",
       "\n",
       "    for (var i=0; i<frames.length; i++)\n",
       "    {\n",
       "     this.frames[i] = new Image();\n",
       "     this.frames[i].src = frames[i];\n",
       "    }\n",
       "    document.getElementById(this.slider_id).max = this.frames.length - 1;\n",
       "    this.set_frame(this.current_frame);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.get_loop_state = function(){\n",
       "    var button_group = document[this.loop_select_id].state;\n",
       "    for (var i = 0; i < button_group.length; i++) {\n",
       "        var button = button_group[i];\n",
       "        if (button.checked) {\n",
       "            return button.value;\n",
       "        }\n",
       "    }\n",
       "    return undefined;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.set_frame = function(frame){\n",
       "    this.current_frame = frame;\n",
       "    document.getElementById(this.img_id).src = this.frames[this.current_frame].src;\n",
       "    document.getElementById(this.slider_id).value = this.current_frame;\n",
       "  }\n",
       "\n",
       "  Animation.prototype.next_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.min(this.frames.length - 1, this.current_frame + 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.previous_frame = function()\n",
       "  {\n",
       "    this.set_frame(Math.max(0, this.current_frame - 1));\n",
       "  }\n",
       "\n",
       "  Animation.prototype.first_frame = function()\n",
       "  {\n",
       "    this.set_frame(0);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.last_frame = function()\n",
       "  {\n",
       "    this.set_frame(this.frames.length - 1);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.slower = function()\n",
       "  {\n",
       "    this.interval /= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.faster = function()\n",
       "  {\n",
       "    this.interval *= 0.7;\n",
       "    if(this.direction > 0){this.play_animation();}\n",
       "    else if(this.direction < 0){this.reverse_animation();}\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_forward = function()\n",
       "  {\n",
       "    this.current_frame += 1;\n",
       "    if(this.current_frame < this.frames.length){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.first_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.last_frame();\n",
       "        this.reverse_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.last_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.anim_step_reverse = function()\n",
       "  {\n",
       "    this.current_frame -= 1;\n",
       "    if(this.current_frame >= 0){\n",
       "      this.set_frame(this.current_frame);\n",
       "    }else{\n",
       "      var loop_state = this.get_loop_state();\n",
       "      if(loop_state == \"loop\"){\n",
       "        this.last_frame();\n",
       "      }else if(loop_state == \"reflect\"){\n",
       "        this.first_frame();\n",
       "        this.play_animation();\n",
       "      }else{\n",
       "        this.pause_animation();\n",
       "        this.first_frame();\n",
       "      }\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.pause_animation = function()\n",
       "  {\n",
       "    this.direction = 0;\n",
       "    if (this.timer){\n",
       "      clearInterval(this.timer);\n",
       "      this.timer = null;\n",
       "    }\n",
       "  }\n",
       "\n",
       "  Animation.prototype.play_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = 1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_forward();}, this.interval);\n",
       "  }\n",
       "\n",
       "  Animation.prototype.reverse_animation = function()\n",
       "  {\n",
       "    this.pause_animation();\n",
       "    this.direction = -1;\n",
       "    var t = this;\n",
       "    if (!this.timer) this.timer = setInterval(function(){t.anim_step_reverse();}, this.interval);\n",
       "  }\n",
       "</script>\n",
       "\n",
       "<div class=\"animation\" align=\"center\">\n",
       "    <img id=\"_anim_imgZBATBBIQHBNUAOBR\">\n",
       "    <br>\n",
       "    <input id=\"_anim_sliderZBATBBIQHBNUAOBR\" type=\"range\" style=\"width:350px\" name=\"points\" min=\"0\" max=\"1\" step=\"1\" value=\"0\" onchange=\"animZBATBBIQHBNUAOBR.set_frame(parseInt(this.value));\"></input>\n",
       "    <br>\n",
       "    <button onclick=\"animZBATBBIQHBNUAOBR.slower()\">&#8211;</button>\n",
       "    <button onclick=\"animZBATBBIQHBNUAOBR.first_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZBATBBIQHBNUAOBR.previous_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZBATBBIQHBNUAOBR.reverse_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZBATBBIQHBNUAOBR.pause_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZBATBBIQHBNUAOBR.play_animation()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZBATBBIQHBNUAOBR.next_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZBATBBIQHBNUAOBR.last_frame()\"><img class=\"anim_icon\" src=\"\"></button>\n",
       "    <button onclick=\"animZBATBBIQHBNUAOBR.faster()\">+</button>\n",
       "  <form action=\"#n\" name=\"_anim_loop_selectZBATBBIQHBNUAOBR\" class=\"anim_control\">\n",
       "    <input type=\"radio\" name=\"state\" value=\"once\" > Once </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"loop\" checked> Loop </input>\n",
       "    <input type=\"radio\" name=\"state\" value=\"reflect\" > Reflect </input>\n",
       "  </form>\n",
       "</div>\n",
       "\n",
       "\n",
       "<script language=\"javascript\">\n",
       "  /* Instantiate the Animation class. */\n",
       "  /* The IDs given should match those used in the template above. */\n",
       "  (function() {\n",
       "    var img_id = \"_anim_imgZBATBBIQHBNUAOBR\";\n",
       "    var slider_id = \"_anim_sliderZBATBBIQHBNUAOBR\";\n",
       "    var loop_select_id = \"_anim_loop_selectZBATBBIQHBNUAOBR\";\n",
       "    var frames = new Array(0);\n",
       "    \n",
       "  frames[0] = \"\"\n",
       "  frames[1] = \"\"\n",
       "  frames[2] = \"\"\n",
       "  frames[3] = \"\"\n",
       "  frames[4] = \"\"\n",
       "  frames[5] = \"\"\n",
       "  frames[6] = \"\"\n",
       "  frames[7] = \"\"\n",
       "  frames[8] = \"\"\n",
       "  frames[9] = \"\"\n",
       "  frames[10] = \"\"\n",
       "  frames[11] = \"\"\n",
       "  frames[12] = \"\"\n",
       "  frames[13] = \"\"\n",
       "  frames[14] = \"\"\n",
       "  frames[15] = \"\"\n",
       "  frames[16] = \"\"\n",
       "  frames[17] = \"\"\n",
       "  frames[18] = \"\"\n",
       "  frames[19] = \"\"\n",
       "  frames[20] = \"\"\n",
       "  frames[21] = \"\"\n",
       "  frames[22] = \"\"\n",
       "  frames[23] = \"\"\n",
       "  frames[24] = \"\"\n",
       "  frames[25] = \"\"\n",
       "  frames[26] = \"\"\n",
       "  frames[27] = \"\"\n",
       "  frames[28] = \"\"\n",
       "  frames[29] = \"\"\n",
       "  frames[30] = \"\"\n",
       "  frames[31] = \"\"\n",
       "  frames[32] = \"\"\n",
       "  frames[33] = \"\"\n",
       "  frames[34] = \"\"\n",
       "  frames[35] = \"\"\n",
       "  frames[36] = \"\"\n",
       "  frames[37] = \"\"\n",
       "  frames[38] = \"\"\n",
       "  frames[39] = \"\"\n",
       "  frames[40] = \"\"\n",
       "  frames[41] = \"\"\n",
       "  frames[42] = \"\"\n",
       "  frames[43] = \"\"\n",
       "  frames[44] = \"\"\n",
       "  frames[45] = \"\"\n",
       "  frames[46] = \"\"\n",
       "  frames[47] = \"\"\n",
       "  frames[48] = \"\"\n",
       "  frames[49] = \"\"\n",
       "  frames[50] = \"\"\n",
       "  frames[51] = \"\"\n",
       "  frames[52] = \"\"\n",
       "  frames[53] = \"\"\n",
       "  frames[54] = \"\"\n",
       "  frames[55] = \"\"\n",
       "  frames[56] = \"\"\n",
       "  frames[57] = \"\"\n",
       "  frames[58] = \"\"\n",
       "  frames[59] = \"\"\n",
       "  frames[60] = \"\"\n",
       "  frames[61] = \"\"\n",
       "  frames[62] = \"\"\n",
       "  frames[63] = \"\"\n",
       "  frames[64] = \"\"\n",
       "  frames[65] = \"\"\n",
       "  frames[66] = \"\"\n",
       "  frames[67] = \"\"\n",
       "  frames[68] = \"\"\n",
       "  frames[69] = \"\"\n",
       "  frames[70] = \"\"\n",
       "  frames[71] = \"\"\n",
       "  frames[72] = \"\"\n",
       "  frames[73] = \"\"\n",
       "  frames[74] = \"\"\n",
       "  frames[75] = \"\"\n",
       "  frames[76] = \"\"\n",
       "  frames[77] = \"\"\n",
       "  frames[78] = \"\"\n",
       "  frames[79] = \"\"\n",
       "  frames[80] = \"\"\n",
       "  frames[81] = \"\"\n",
       "  frames[82] = \"\"\n",
       "  frames[83] = \"\"\n",
       "  frames[84] = \"\"\n",
       "  frames[85] = \"\"\n",
       "  frames[86] = \"\"\n",
       "  frames[87] = \"\"\n",
       "  frames[88] = \"\"\n",
       "  frames[89] = \"\"\n",
       "  frames[90] = \"\"\n",
       "  frames[91] = \"\"\n",
       "  frames[92] = \"\"\n",
       "  frames[93] = \"\"\n",
       "  frames[94] = \"\"\n",
       "  frames[95] = \"\"\n",
       "  frames[96] = \"\"\n",
       "  frames[97] = \"\"\n",
       "  frames[98] = \"\"\n",
       "  frames[99] = \"\"\n",
       "  frames[100] = \"\"\n",
       "  frames[101] = \"\"\n",
       "  frames[102] = \"\"\n",
       "  frames[103] = \"\"\n",
       "  frames[104] = \"\"\n",
       "  frames[105] = \"\"\n",
       "  frames[106] = \"\"\n",
       "  frames[107] = \"\"\n",
       "  frames[108] = \"\"\n",
       "  frames[109] = \"\"\n",
       "  frames[110] = \"\"\n",
       "  frames[111] = \"\"\n",
       "  frames[112] = \"\"\n",
       "  frames[113] = \"\"\n",
       "  frames[114] = \"\"\n",
       "  frames[115] = \"\"\n",
       "  frames[116] = \"\"\n",
       "  frames[117] = \"\"\n",
       "  frames[118] = \"\"\n",
       "  frames[119] = \"\"\n",
       "  frames[120] = \"\"\n",
       "  frames[121] = \"\"\n",
       "  frames[122] = \"\"\n",
       "  frames[123] = \"\"\n",
       "  frames[124] = \"\"\n",
       "  frames[125] = \"\"\n",
       "  frames[126] = \"\"\n",
       "  frames[127] = \"\"\n",
       "  frames[128] = \"\"\n",
       "  frames[129] = \"\"\n",
       "  frames[130] = \"\"\n",
       "  frames[131] = \"\"\n",
       "  frames[132] = \"\"\n",
       "  frames[133] = \"\"\n",
       "  frames[134] = \"\"\n",
       "  frames[135] = \"\"\n",
       "  frames[136] = \"\"\n",
       "  frames[137] = \"\"\n",
       "  frames[138] = \"\"\n",
       "  frames[139] = \"\"\n",
       "  frames[140] = \"\"\n",
       "  frames[141] = \"\"\n",
       "  frames[142] = \"\"\n",
       "  frames[143] = \"\"\n",
       "  frames[144] = \"\"\n",
       "  frames[145] = \"\"\n",
       "  frames[146] = \"\"\n",
       "  frames[147] = \"\"\n",
       "  frames[148] = \"\"\n",
       "  frames[149] = \"\"\n",
       "  frames[150] = \"\"\n",
       "  frames[151] = \"\"\n",
       "  frames[152] = \"\"\n",
       "  frames[153] = \"\"\n",
       "  frames[154] = \"\"\n",
       "  frames[155] = \"\"\n",
       "  frames[156] = \"\"\n",
       "\n",
       "\n",
       "    /* set a timeout to make sure all the above elements are created before\n",
       "       the object is initialized. */\n",
       "    setTimeout(function() {\n",
       "        animZBATBBIQHBNUAOBR = new Animation(frames, img_id, slider_id, 50, loop_select_id);\n",
       "    }, 0);\n",
       "  })()\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if IN_COLAB:  # for colab\n",
    "    import base64\n",
    "    import glob\n",
    "    import io\n",
    "    import os\n",
    "\n",
    "    from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "    def ipython_show_video(path: str) -> None:\n",
    "        \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "        if not os.path.isfile(path):\n",
    "            raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "        video = io.open(path, \"r+b\").read()\n",
    "        encoded = base64.b64encode(video)\n",
    "\n",
    "        display(HTML(\n",
    "            data=\"\"\"\n",
    "            <video alt=\"test\" controls>\n",
    "            <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "            </video>\n",
    "            \"\"\".format(encoded.decode(\"ascii\"))\n",
    "        ))\n",
    "\n",
    "    list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    print(latest_file)\n",
    "    ipython_show_video(latest_file)\n",
    "    \n",
    "else:  # for jupyter\n",
    "    from matplotlib import animation\n",
    "    from JSAnimation.IPython_display import display_animation\n",
    "    from IPython.display import display\n",
    "\n",
    "\n",
    "    def display_frames_as_gif(frames: List[np.ndarray]) -> None:\n",
    "        \"\"\"Displays a list of frames as a gif, with controls.\"\"\"\n",
    "        patch = plt.imshow(frames[0])\n",
    "        plt.axis('off')\n",
    "\n",
    "        def animate(i):\n",
    "            patch.set_data(frames[i])\n",
    "\n",
    "        anim = animation.FuncAnimation(\n",
    "            plt.gcf(), animate, frames = len(frames), interval=50\n",
    "        )\n",
    "        display(display_animation(anim, default_mode='loop'))\n",
    "\n",
    "\n",
    "    # display \n",
    "    display_frames_as_gif(frames)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
